package com.zrh.jsd.service.studydemo.threadpool;

import java.util.concurrent.*;

public class CompleteFutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService cachePool = Executors.newCachedThreadPool();
        CompletableFuture<Integer> completableFutureOne = new CompletableFuture<>();
        cachePool.submit(() -> {
            try {
                System.out.println("completableFutureOne异步任务开始====start====");
                TimeUnit.SECONDS.sleep(3);
                completableFutureOne.complete(3); // 传入异步计算结果时回调，从而获取到异步任务的结果。
                System.out.println("completableFutureOne异步任务结束====end====");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 提交了一步任务后，主线程可以继续干一些其他的事情
        // WhenComplete 方法返回的 CompletableFuture 仍然是原来的 CompletableFuture 计算结果.
        CompletableFuture<Integer> completableFutureTwo = completableFutureOne.whenComplete((s, throwable) -> {
            System.out.println("异步任务completableFutureOne执行完毕时打印异步任务的执行结果: " + s);
            return;
        });
        doSomeThinsElese();

        // ThenApply 方法返回的是一个新的 completeFuture. completableFutureOne 会最后结束
        CompletableFuture<Integer> completableFutureThree = completableFutureTwo.thenApply(s -> {
            System.out.println("当异步任务执行结束时, 根据上一次的异步任务结果, 继续开始一个新的异步任务! s = " + s);
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当异步任务执行结束时, 根据上一次的异步任务结果, 继续开始一个新的异步任务结束! s = " + s);
            return s;
        });

    }

    private static void doSomeThinsElese() throws InterruptedException {
        System.out.println("主线任务开始==doSomeThinsElese===start=");
        TimeUnit.SECONDS.sleep(1);
        System.out.println("主线任务结束==doSomeThinsElese===end=接下来获取异步计算的结果去干剩下的事情=");
    }
}
